//package com.ruoyi.foodworks.service.impl;
//
//import java.util.List;
//import java.util.Map;
//import java.util.HashMap;
//import java.util.ArrayList;
//import java.util.Set;
//import java.util.HashSet;
//import com.ruoyi.common.utils.DateUtils;
//import com.ruoyi.foodworks.service.LikesService;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;
//import com.ruoyi.common.core.redis.RedisCache;
//import com.ruoyi.foodworks.mapper.LikesMapper;
//import com.ruoyi.foodworks.domain.Likes;
//import com.ruoyi.foodworks.domain.LikesVO;
//import com.ruoyi.foodworks.service.LikesService;
//
///**
// * 作品点赞Service业务层处理
// *
// * @author lpt
// * @date 2025-08-12
// */
//@Service
//public class LikesServiceImpl implements LikesService
//{
//    @Autowired
//    private LikesMapper likesMapper;
//
//    @Autowired
//    private RedisCache redisCache;
//
//    /**
//     * 查询作品点赞
//     *
//     * @param id 作品点赞主键
//     * @return 作品点赞
//     */
//    @Override
//    public Likes selectLikesById(Integer id)
//    {
//        return likesMapper.selectLikesById(id);
//    }
//
//    /**
//     * 查询作品点赞列表
//     *
//     * @param likes 作品点赞
//     * @return 作品点赞
//     */
//    @Override
//    public List<Likes> selectLikesList(Likes likes)
//    {
//        return likesMapper.selectLikesList(likes);
//    }
//
//    /**
//     * 新增作品点赞
//     *
//     * @param likes 作品点赞
//     * @return 结果
//     */
//    @Override
//    public int insertLikes(Likes likes)
//    {
//        likes.setCreateTime(DateUtils.getNowDate());
//        return likesMapper.insertLikes(likes);
//    }
//
//    /**
//     * 修改作品点赞
//     *
//     * @param likes 作品点赞
//     * @return 结果
//     */
//    @Override
//    public int updateLikes(Likes likes)
//    {
//        return likesMapper.updateLikes(likes);
//    }
//
//    /**
//     * 批量删除作品点赞
//     *
//     * @param ids 需要删除的作品点赞主键
//     * @return 结果
//     */
//    @Override
//    public int deleteLikesByIds(Integer[] ids)
//    {
//        return likesMapper.deleteLikesByIds(ids);
//    }
//
//    /**
//     * 删除作品点赞信息
//     *
//     * @param id 作品点赞主键
//     * @return 结果
//     */
//    @Override
//    public int deleteLikesById(Integer id)
//    {
//        return likesMapper.deleteLikesById(id);
//    }
//
//    /**
//     * 查询作品点赞列表（包含用户昵称和作品内容）
//     *
//     * @param likes 作品点赞
//     * @return 作品点赞集合
//     */
//    @Override
//    public List<LikesVO> selectLikesVOList(Likes likes)
//    {
//        return likesMapper.selectLikesVOList(likes);
//    }
//
//    /**
//     * Redis点赞操作（点赞/取消点赞）
//     *
//     * @param likerUid 点赞用户ID
//     * @param authorUid 被点赞作者ID
//     * @param targetId 目标ID
//     * @param targetType 目标类型
//     * @return 操作结果
//     */
//    @Override
//    @Transactional
//    public Map<String, Object> redisLike(Integer likerUid, Integer authorUid, Integer targetId, Integer targetType)
//    {
//        Map<String, Object> result = new HashMap<>();
//
//        try {
//            System.out.println("=== 开始点赞操作 ===");
//            System.out.println("参数: likerUid=" + likerUid + ", authorUid=" + authorUid + ", targetId=" + targetId + ", targetType=" + targetType);
//
//            // 构建Redis键
//            String userLikeKey = "user_like:" + likerUid + ":" + targetType;
//            String countKey = "like_count:" + targetType + ":" + targetId;
//            System.out.println("Redis键: " + userLikeKey + ", " + countKey);
//            //清空缓存
//            //redisCache.deleteObject(userLikeKey);
//            // 获取用户当前点赞状态
//            Set<String> userLikes = redisCache.getCacheSet(userLikeKey);
//            System.out.println("Redis中用户点赞作品: " + userLikes);
//            if (userLikes == null) {
//                userLikes = new HashSet<>();
//
//            }
//
//            boolean isLiked = userLikes.contains(targetId.toString());
//            System.out.println("Redis中是否已点赞: " + isLiked);
//
//            // 查询数据库中的点赞记录
//            Likes queryLike = new Likes();
//            queryLike.setLikerUid(likerUid);
//            queryLike.setTargetId(targetId);
//            queryLike.setTargetType((long) targetType);
//            List<Likes> existingLikes = likesMapper.selectLikesList(queryLike);
//
//            System.out.println("数据库中查询到的记录数: " + existingLikes.size());
//            if (!existingLikes.isEmpty()) {
//                System.out.println("数据库记录详情: " + existingLikes.get(0));
//            }
//
//            if (isLiked) {
//                // 取消点赞 - 物理删除
//                System.out.println("执行取消点赞操作");
//                userLikes.remove(targetId.toString());
//                redisCache.setCacheSet(userLikeKey, userLikes);
//
//                // 更新Redis点赞计数
//                String currentCount = redisCache.getCacheObject(countKey);
//                if (currentCount != null) {
//                    int count = Math.max(0, Integer.parseInt(currentCount) - 1);
//                    redisCache.setCacheObject(countKey, String.valueOf(count));
//                }
//
//                // 物理删除数据库记录
//                if (!existingLikes.isEmpty()) {
//                    Likes existingLike = existingLikes.get(0);
//                    int deleteResult = likesMapper.deleteLikesById(existingLike.getId());
//                    System.out.println("物理删除数据库记录结果: " + deleteResult);
//                }
//
//                result.put("success", true);
//                result.put("action", "unlike");
//                result.put("message", "取消点赞成功");
//
//            } else {
//                // 添加点赞
//                System.out.println("执行添加点赞操作");
//                userLikes.add(targetId.toString());
//                redisCache.setCacheSet(userLikeKey, userLikes);
//
//                // 更新Redis点赞计数
//                String currentCount = redisCache.getCacheObject(countKey);
//                int count = currentCount != null ? Integer.parseInt(currentCount) + 1 : 1;
//                redisCache.setCacheObject(countKey, String.valueOf(count));
//
//                // 处理数据库记录 - 物理删除后，这里只需要插入新记录
//                if (!existingLikes.isEmpty()) {
//                    // 有记录，说明是物理删除后的重新点赞，直接插入新记录
//                    System.out.println("重新点赞，插入新记录");
//                    Likes newLike = new Likes();
//                    newLike.setLikerUid(likerUid);
//                    newLike.setAuthorUid(authorUid);
//                    newLike.setTargetId(targetId);
//                    newLike.setTargetType((long) targetType);
//                    newLike.setDel(0);
//                    newLike.setCreateTime(DateUtils.getNowDate());
//                    int insertResult = likesMapper.insertLikes(newLike);
//                    System.out.println("插入数据库记录结果: " + insertResult);
//                    System.out.println("新记录ID: " + newLike.getId());
//                } else {
//                    // 无记录，插入新记录
//                    System.out.println("插入新的点赞记录");
//                    Likes newLike = new Likes();
//                    newLike.setLikerUid(likerUid);
//                    newLike.setAuthorUid(authorUid);
//                    newLike.setTargetId(targetId);
//                    newLike.setTargetType((long) targetType);
//                    newLike.setDel(0);
//                    newLike.setCreateTime(DateUtils.getNowDate());
//                    int insertResult = likesMapper.insertLikes(newLike);
//                    System.out.println("插入数据库记录结果: " + insertResult);
//                    System.out.println("新记录ID: " + newLike.getId());
//                }
//
//                result.put("success", true);
//                result.put("action", "like");
//                result.put("message", "点赞成功");
//            }
//
//            // 获取最新的点赞数
//            String finalCount = redisCache.getCacheObject(countKey);
//            result.put("likeCount", finalCount != null ? Integer.parseInt(finalCount) : 0);
//
//            System.out.println("=== 点赞操作完成 ===");
//
//        } catch (Exception e) {
//            System.out.println("点赞操作异常: " + e.getMessage());
//            e.printStackTrace();
//            result.put("success", false);
//            result.put("message", "操作失败：" + e.getMessage());
//        }
//
//        return result;
//    }
//
//    /**
//     * 获取用户点赞状态
//     *
//     * @param userId 用户ID
//     * @param targetIds 目标ID列表
//     * @param targetType 目标类型
//     * @return 已点赞的目标ID列表
//     */
//    @Override
//    public List<Integer> getUserLikeStatus(Integer userId, List<Integer> targetIds, Integer targetType)
//    {
//        List<Integer> likedTargetIds = new ArrayList<>();
//
//        try {
//            String userLikeKey = "user_like:" + userId + ":" + targetType;
//            System.out.println("Redis用户点赞键: " + userLikeKey);
//            Set<String> likedIds = redisCache.getCacheSet(userLikeKey);
//            System.out.println("Redis中已点赞的ID列表: " + likedIds);
//
//            if (likedIds != null) {
//                for (String id : likedIds) {
//                    if (targetIds.contains(Integer.parseInt(id))) {
//                        likedTargetIds.add(Integer.parseInt(id));
//                    }
//                }
//            }
//        } catch (Exception e) {
//            // 如果Redis获取失败，从数据库查询
//            Likes queryLike = new Likes();
//            queryLike.setLikerUid(userId);
//            queryLike.setTargetType((long) targetType);
//            List<Likes> dbLikes = likesMapper.selectLikesList(queryLike);
//
//            for (Likes like : dbLikes) {
//                if (targetIds.contains(like.getTargetId())) {
//                    likedTargetIds.add(like.getTargetId());
//                }
//            }
//        }
//
//        return likedTargetIds;
//    }
//
//    /**
//     * 校验并同步数据库点赞状态到Redis
//     *
//     * @param userId 用户ID
//     * @param targetIds 目标ID列表
//     * @param targetType 目标类型
//     * @return 数据库中的点赞状态
//     */
//    public List<Integer> validateAndSyncLikeStatus(Integer userId, List<Integer> targetIds, Integer targetType)
//    {
//        List<Integer> resultIds = new ArrayList<>();
//
//        try {
//            String userLikeKey = "user_like:" + userId + ":" + targetType;
//
//            // 从数据库查询点赞记录
//            Likes queryLike = new Likes();
//            queryLike.setLikerUid(userId);
//            queryLike.setTargetType((long) targetType);
//            List<Likes> dbLikes = likesMapper.selectLikesList(queryLike);
//
//            // 获取数据库中的点赞作品ID
//            Set<String> dbLikedIds = new HashSet<>();
//            for (Likes like : dbLikes) {
//                if (targetIds.contains(like.getTargetId())) {
//                    dbLikedIds.add(like.getTargetId().toString());
//                    resultIds.add(like.getTargetId());
//                }
//
//            }
//
//            // 同步Redis状态到数据库状态
//            redisCache.setCacheSet(userLikeKey, dbLikedIds);
//
//            // 更新点赞计数
//            for (Integer targetId : targetIds) {
//                String countKey = "like_count:" + targetType + ":" + targetId;
//                if (dbLikedIds.contains(targetId.toString())) {
//                    // 如果数据库中有记录，确保Redis计数正确
//                    String currentCount = redisCache.getCacheObject(countKey);
//                    if (currentCount == null || Integer.parseInt(currentCount) <= 0) {
//                        // 重新计算该作品的点赞数
//                        Likes countQuery = new Likes();
//                        countQuery.setTargetId(targetId);
//                        countQuery.setTargetType((long) targetType);
//                        List<Likes> workLikes = likesMapper.selectLikesList(countQuery);
//                        redisCache.setCacheObject(countKey, String.valueOf(workLikes.size()));
//                    }
//                }
//            }
//
//        } catch (Exception e) {
//            // 异常处理，返回空列表
//        }
//
//        return resultIds;
//    }
//
//    /**
//     * 获取作品点赞数
//     *
//     * @param targetId 目标ID
//     * @param targetType 目标类型
//     * @return 点赞数
//     */
//    @Override
//    public Integer getLikeCount(Integer targetId, Integer targetType)
//    {
//        try {
//            String countKey = "like_count:" + targetType + ":" + targetId;
//            String count = redisCache.getCacheObject(countKey);
//
//            if (count != null) {
//                return Integer.parseInt(count);
//            } else {
//                // 从数据库查询
//                Likes queryLike = new Likes();
//                queryLike.setTargetId(targetId);
//                queryLike.setTargetType((long) targetType);
//                List<Likes> likes = likesMapper.selectLikesList(queryLike);
//
//                // 缓存到Redis
//                redisCache.setCacheObject(countKey, String.valueOf(likes.size()));
//                return likes.size();
//            }
//        } catch (Exception e) {
//            return 0;
//        }
//    }
//
//    /**
//     * 批量获取作品点赞数
//     *
//     * @param targetIds 目标ID列表
//     * @param targetType 目标类型
//     * @return 点赞数映射
//     */
//    @Override
//    public Map<Integer, Integer> getLikeCounts(List<Integer> targetIds, Integer targetType)
//    {
//        Map<Integer, Integer> result = new HashMap<>();
//
//        for (Integer targetId : targetIds) {
//            result.put(targetId, getLikeCount(targetId, targetType));
//        }
//
//        return result;
//    }
//}


package com.ruoyi.foodworks.service.impl;

import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.foodworks.service.LikesService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.foodworks.mapper.LikesMapper;
import com.ruoyi.foodworks.domain.Likes;
import com.ruoyi.foodworks.domain.LikesVO;
import com.ruoyi.foodworks.service.LikesService;

import javax.annotation.Resource;

/**
 * 作品点赞Service业务层处理
 *
 * @author lpt
 * @date 2025-08-12
 */

@Service("foodWorksLikesServiceImpl")
public class LikesServiceImpl implements LikesService
{
    @Resource
    private LikesMapper likesMapper;

    @Autowired
    private RedisCache redisCache;

    /**
     * 查询作品点赞
     *
     * @param id 作品点赞主键
     * @return 作品点赞
     */
    @Override
    public Likes selectLikesById(Integer id)
    {
        return likesMapper.selectLikesById(id);
    }

    /**
     * 查询作品点赞列表
     *
     * @param likes 作品点赞
     * @return 作品点赞
     */
    @Override
    public List<Likes> selectLikesList(Likes likes)
    {
        return likesMapper.selectLikesList(likes);
    }

    /**
     * 新增作品点赞
     *
     * @param likes 作品点赞
     * @return 结果
     */
    @Override
    public int insertLikes(Likes likes)
    {
        likes.setCreateTime(DateUtils.getNowDate());
        return likesMapper.insertLikes(likes);
    }

    /**
     * 修改作品点赞
     *
     * @param likes 作品点赞
     * @return 结果
     */
    @Override
    public int updateLikes(Likes likes)
    {
        return likesMapper.updateLikes(likes);
    }

    /**
     * 批量删除作品点赞
     *
     * @param ids 需要删除的作品点赞主键
     * @return 结果
     */
    @Override
    public int deleteLikesByIds(Integer[] ids)
    {
        return likesMapper.deleteLikesByIds(ids);
    }

    /**
     * 删除作品点赞信息
     *
     * @param id 作品点赞主键
     * @return 结果
     */
    @Override
    public int deleteLikesById(Integer id)
    {
        return likesMapper.deleteLikesById(id);
    }

    /**
     * 查询作品点赞列表（包含用户昵称和作品内容）
     *
     * @param likes 作品点赞
     * @return 作品点赞集合
     */
    @Override
    public List<LikesVO> selectLikesVOList(Likes likes)
    {
        return likesMapper.selectLikesVOList(likes);
    }

    /**
     * Redis点赞操作（点赞/取消点赞）
     *
     * @param likerUid 点赞用户ID
     * @param authorUid 被点赞作者ID
     * @param targetId 目标ID
     * @param targetType 目标类型
     * @return 操作结果
     */
    @Override
    @Transactional
    public Map<String, Object> redisLike(Integer likerUid, Integer authorUid, Integer targetId, Integer targetType)
    {
        Map<String, Object> result = new HashMap<>();

        try {
            System.out.println("=== 开始点赞操作 ===");
            System.out.println("参数: likerUid=" + likerUid + ", authorUid=" + authorUid + ", targetId=" + targetId + ", targetType=" + targetType);

            // 1. 强制从数据库查询最新状态（确保数据一致性）
            Likes queryLike = new Likes();
            queryLike.setLikerUid(likerUid);
            queryLike.setTargetId(targetId);
            queryLike.setTargetType((long) targetType);
            List<Likes> existingLikes = likesMapper.selectLikesList(queryLike);

            boolean isLiked = !existingLikes.isEmpty();
            System.out.println("数据库中是否已点赞: " + isLiked);

            if (isLiked) {
                // 取消点赞
                System.out.println("执行取消点赞操作");
                Likes existingLike = existingLikes.get(0);
                int deleteResult = likesMapper.deleteLikesById(existingLike.getId());

                if (deleteResult > 0) {
                    // 更新Redis缓存（强制更新，不考虑缓存过期）
                    forceUpdateRedisLikeStatus(likerUid, targetId, targetType, false);
                    forceUpdateRedisLikeCount(targetId, targetType, -1);

                    result.put("success", true);
                    result.put("action", "unlike");
                    result.put("message", "取消点赞成功");
                } else {
                    result.put("success", false);
                    result.put("message", "取消点赞失败");
                }
            } else {
                // 添加点赞
                System.out.println("执行添加点赞操作");
                Likes newLike = new Likes();
                newLike.setLikerUid(likerUid);
                newLike.setAuthorUid(authorUid);
                newLike.setTargetId(targetId);
                newLike.setTargetType((long) targetType);
                newLike.setDel(0);
                newLike.setCreateTime(DateUtils.getNowDate());

                int insertResult = likesMapper.insertLikes(newLike);

                if (insertResult > 0) {
                    // 更新Redis缓存（强制更新）
                    forceUpdateRedisLikeStatus(likerUid, targetId, targetType, true);
                    forceUpdateRedisLikeCount(targetId, targetType, 1);

                    result.put("success", true);
                    result.put("action", "like");
                    result.put("message", "点赞成功");
                } else {
                    result.put("success", false);
                    result.put("message", "点赞失败");
                }
            }

            // 获取最新点赞数（从数据库重新计算）
            int likeCount = calculateLikeCountFromDatabase(targetId, targetType);
            result.put("likeCount", likeCount);

            System.out.println("=== 点赞操作完成 ===");

        } catch (Exception e) {
            System.out.println("点赞操作异常: " + e.getMessage());
            e.printStackTrace();
            result.put("success", false);
            result.put("message", "操作失败：" + e.getMessage());
        }

        return result;
    }

    /**
     * 获取用户点赞状态
     *
     * @param userId 用户ID
     * @param targetIds 目标ID列表
     * @param targetType 目标类型
     * @return 已点赞的目标ID列表
     */
    @Override
    public List<Integer> getUserLikeStatus(Integer userId, List<Integer> targetIds, Integer targetType)
    {
        List<Integer> likedTargetIds = new ArrayList<>();

        try {
            // 页面刷新时，优先从数据库获取最新状态
            likedTargetIds = getLikeStatusFromDatabase(userId, targetIds, targetType);

            // 同步到Redis缓存（预热缓存）
            syncLikeStatusToRedis(userId, targetIds, targetType, likedTargetIds);

        } catch (Exception e) {
            // 数据库查询失败，尝试从Redis获取
            likedTargetIds = getLikeStatusFromRedis(userId, targetIds, targetType);
        }

        return likedTargetIds;
    }

    /**
     * 获取作品点赞数
     *
     * @param targetId 目标ID
     * @param targetType 目标类型
     * @return 点赞数
     */
    @Override
    public Integer getLikeCount(Integer targetId, Integer targetType)
    {
        try {
            // 页面刷新时，优先从数据库获取最新数据
            int count = calculateLikeCountFromDatabase(targetId, targetType);

            // 同步到Redis缓存
            String countKey = "like_count:" + targetType + ":" + targetId;
            redisCache.setCacheObject(countKey, String.valueOf(count));

            return count;

        } catch (Exception e) {
            // 数据库查询失败，尝试从Redis获取
            try {
                String countKey = "like_count:" + targetType + ":" + targetId;
                String count = redisCache.getCacheObject(countKey);
                return count != null ? Integer.parseInt(count) : 0;
            } catch (Exception redisEx) {
                return 0;
            }
        }
    }

    /**
     * 批量获取作品点赞数
     *
     * @param targetIds 目标ID列表
     * @param targetType 目标类型
     * @return 点赞数映射
     */
    @Override
    public Map<Integer, Integer> getLikeCounts(List<Integer> targetIds, Integer targetType)
    {
        Map<Integer, Integer> result = new HashMap<>();

        try {
            // 批量查询数据库
            for (Integer targetId : targetIds) {
                int count = calculateLikeCountFromDatabase(targetId, targetType);
                result.put(targetId, count);

                // 同步到Redis
                String countKey = "like_count:" + targetType + ":" + targetId;
                redisCache.setCacheObject(countKey, String.valueOf(count));
            }

        } catch (Exception e) {
            // 数据库查询失败，从Redis获取
            for (Integer targetId : targetIds) {
                try {
                    String countKey = "like_count:" + targetType + ":" + targetId;
                    String count = redisCache.getCacheObject(countKey);
                    result.put(targetId, count != null ? Integer.parseInt(count) : 0);
                } catch (Exception redisEx) {
                    result.put(targetId, 0);
                }
            }
        }

        return result;
    }

    /**
     * 强制更新Redis点赞状态（不考虑缓存过期）
     */
    private void forceUpdateRedisLikeStatus(Integer userId, Integer targetId, Integer targetType, boolean isLiked) {
        try {
            String userLikeKey = "user_like:" + userId + ":" + targetType;

            // 先获取当前Redis中的所有点赞记录
            Set<String> userLikes = redisCache.getCacheSet(userLikeKey);
            if (userLikes == null) {
                userLikes = new HashSet<>();
            }

            // 更新状态
            if (isLiked) {
                userLikes.add(targetId.toString());
            } else {
                userLikes.remove(targetId.toString());
            }

            // 强制更新Redis（设置较长的过期时间）
            redisCache.setCacheSet(userLikeKey, userLikes);

        } catch (Exception e) {
            // Redis操作失败，记录日志但不影响主流程
            System.out.println("Redis状态更新失败: " + e.getMessage());
        }
    }

    /**
     * 强制更新Redis点赞计数
     */
    private void forceUpdateRedisLikeCount(Integer targetId, Integer targetType, int delta) {
        try {
            String countKey = "like_count:" + targetType + ":" + targetId;
            String currentCount = redisCache.getCacheObject(countKey);

            int count = currentCount != null ? Integer.parseInt(currentCount) : 0;
            count = Math.max(0, count + delta);

            // 强制更新Redis
            redisCache.setCacheObject(countKey, String.valueOf(count));

        } catch (Exception e) {
            System.out.println("Redis计数更新失败: " + e.getMessage());
        }
    }

    /**
     * 从数据库计算点赞数（确保准确性）
     */
    private int calculateLikeCountFromDatabase(Integer targetId, Integer targetType) {
        try {
            Likes queryLike = new Likes();
            queryLike.setTargetId(targetId);
            queryLike.setTargetType((long) targetType);
            List<Likes> likes = likesMapper.selectLikesList(queryLike);
            return likes.size();
        } catch (Exception e) {
            return 0;
        }
    }

    /**
     * 从数据库获取点赞状态（页面刷新时使用）
     */
    private List<Integer> getLikeStatusFromDatabase(Integer userId, List<Integer> targetIds, Integer targetType) {
        List<Integer> likedTargetIds = new ArrayList<>();

        try {
            // 查询数据库
            Likes queryLike = new Likes();
            queryLike.setLikerUid(userId);
            queryLike.setTargetType((long) targetType);
            List<Likes> dbLikes = likesMapper.selectLikesList(queryLike);

            // 筛选出在目标列表中的点赞记录
            for (Likes like : dbLikes) {
                if (targetIds.contains(like.getTargetId())) {
                    likedTargetIds.add(like.getTargetId());
                }
            }

        } catch (Exception e) {
            System.out.println("数据库查询失败: " + e.getMessage());
        }

        return likedTargetIds;
    }

    /**
     * 从Redis获取点赞状态（降级方案）
     */
    private List<Integer> getLikeStatusFromRedis(Integer userId, List<Integer> targetIds, Integer targetType) {
        List<Integer> likedTargetIds = new ArrayList<>();

        try {
            String userLikeKey = "user_like:" + userId + ":" + targetType;
            Set<String> redisLikedIds = redisCache.getCacheSet(userLikeKey);

            if (redisLikedIds != null) {
                for (String id : redisLikedIds) {
                    if (targetIds.contains(Integer.parseInt(id))) {
                        likedTargetIds.add(Integer.parseInt(id));
                    }
                }
            }

        } catch (Exception e) {
            System.out.println("Redis查询失败: " + e.getMessage());
        }

        return likedTargetIds;
    }

    /**
     * 同步点赞状态到Redis（缓存预热）
     */
    private void syncLikeStatusToRedis(Integer userId, List<Integer> targetIds, Integer targetType, List<Integer> likedTargetIds) {
        try {
            String userLikeKey = "user_like:" + userId + ":" + targetType;

            // 获取用户所有点赞记录
            Likes queryLike = new Likes();
            queryLike.setLikerUid(userId);
            queryLike.setTargetType((long) targetType);
            List<Likes> allUserLikes = likesMapper.selectLikesList(queryLike);

            // 构建Redis缓存数据
            Set<String> redisLikedIds = new HashSet<>();
            for (Likes like : allUserLikes) {
                redisLikedIds.add(like.getTargetId().toString());
            }

            // 更新Redis缓存
            redisCache.setCacheSet(userLikeKey, redisLikedIds);

            // 同时更新点赞计数缓存
            for (Integer targetId : targetIds) {
                int count = calculateLikeCountFromDatabase(targetId, targetType);
                String countKey = "like_count:" + targetType + ":" + targetId;
                redisCache.setCacheObject(countKey, String.valueOf(count));
            }

        } catch (Exception e) {
            System.out.println("Redis同步失败: " + e.getMessage());
        }
    }
}

